// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.nav.sell.order.transaction;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.NavSellOrderTransaction;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(NavSellOrderTransaction.class)
@Setter
@Getter
public class NavSellOrderTransactionSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "NavSellOrderTransaction".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("parentNavSellOrder", "nso");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 所属订单管理
   */
  private Long parentNavSellOrder;

  /**
   * 所属订单管理 比较(eq)
   */
  private Long parentNavSellOrderEq;
  /**
   * 所属订单管理 比较(neq)
   */
  private Long parentNavSellOrderNeq;
  /**
   * 所属订单管理 比较(gt)
   */
  private Long parentNavSellOrderGt;
  /**
   * 所属订单管理 比较(gte)
   */
  private Long parentNavSellOrderGte;
  /**
   * 所属订单管理 比较(lt)
   */
  private Long parentNavSellOrderLt;
  /**
   * 所属订单管理 比较(lte)
   */
  private Long parentNavSellOrderLte;
  /**
   * 所属订单管理 比较(contains)
   */
  private Long parentNavSellOrderContains;
  /**
   * 所属订单管理 比较(notcontains)
   */
  private Long parentNavSellOrderNotcontains;
  /**
   * 所属订单管理 比较(startswith)
   */
  private Long parentNavSellOrderStartswith;
  /**
   * 所属订单管理 比较(endswith)
   */
  private Long parentNavSellOrderEndswith;
  /**
   * 所属订单管理 比较(isnull)
   */
  private Boolean parentNavSellOrderIsnull;
  /**
   * 所属订单管理 比较(isnotnull)
   */
  private Boolean parentNavSellOrderIsnotnull;
  /**
   * 所属订单管理的系统单号 比较(eq)
   */
  private String parentNavSellOrderOrderIdEq;
  /**
   * 所属订单管理的系统单号 比较(neq)
   */
  private String parentNavSellOrderOrderIdNeq;
  /**
   * 所属订单管理的系统单号 比较(gt)
   */
  private String parentNavSellOrderOrderIdGt;
  /**
   * 所属订单管理的系统单号 比较(gte)
   */
  private String parentNavSellOrderOrderIdGte;
  /**
   * 所属订单管理的系统单号 比较(lt)
   */
  private String parentNavSellOrderOrderIdLt;
  /**
   * 所属订单管理的系统单号 比较(lte)
   */
  private String parentNavSellOrderOrderIdLte;
  /**
   * 所属订单管理的系统单号 比较(contains)
   */
  private String parentNavSellOrderOrderIdContains;
  /**
   * 所属订单管理的系统单号 比较(notcontains)
   */
  private String parentNavSellOrderOrderIdNotcontains;
  /**
   * 所属订单管理的系统单号 比较(startswith)
   */
  private String parentNavSellOrderOrderIdStartswith;
  /**
   * 所属订单管理的系统单号 比较(endswith)
   */
  private String parentNavSellOrderOrderIdEndswith;
  /**
   * 所属订单管理的系统单号 比较(isnull)
   */
  private Boolean parentNavSellOrderOrderIdIsnull;
  /**
   * 所属订单管理的系统单号 比较(isnotnull)
   */
  private Boolean parentNavSellOrderOrderIdIsnotnull;

  /**
   * 所属订单管理(范围搜索)
   */
  private List<Long> parentNavSellOrderInList;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 客付税费
   */
  private java.math.BigDecimal tax;

  /**
   * 最小客付税费
   */
  private java.math.BigDecimal taxMin;

  /**
   * 最大客付税费
   */
  private java.math.BigDecimal taxMax;

  /**
   * 客付税费 比较(eq)
   */
  private java.math.BigDecimal taxEq;
  /**
   * 客付税费 比较(neq)
   */
  private java.math.BigDecimal taxNeq;
  /**
   * 客付税费 比较(gt)
   */
  private java.math.BigDecimal taxGt;
  /**
   * 客付税费 比较(gte)
   */
  private java.math.BigDecimal taxGte;
  /**
   * 客付税费 比较(lt)
   */
  private java.math.BigDecimal taxLt;
  /**
   * 客付税费 比较(lte)
   */
  private java.math.BigDecimal taxLte;
  /**
   * 客付税费 比较(contains)
   */
  private java.math.BigDecimal taxContains;
  /**
   * 客付税费 比较(notcontains)
   */
  private java.math.BigDecimal taxNotcontains;
  /**
   * 客付税费 比较(startswith)
   */
  private java.math.BigDecimal taxStartswith;
  /**
   * 客付税费 比较(endswith)
   */
  private java.math.BigDecimal taxEndswith;
  /**
   * 客付税费 比较(isnull)
   */
  private Boolean taxIsnull;
  /**
   * 客付税费 比较(isnotnull)
   */
  private Boolean taxIsnotnull;

  /**
   * 小费
   */
  private java.math.BigDecimal tip;

  /**
   * 最小小费
   */
  private java.math.BigDecimal tipMin;

  /**
   * 最大小费
   */
  private java.math.BigDecimal tipMax;

  /**
   * 小费 比较(eq)
   */
  private java.math.BigDecimal tipEq;
  /**
   * 小费 比较(neq)
   */
  private java.math.BigDecimal tipNeq;
  /**
   * 小费 比较(gt)
   */
  private java.math.BigDecimal tipGt;
  /**
   * 小费 比较(gte)
   */
  private java.math.BigDecimal tipGte;
  /**
   * 小费 比较(lt)
   */
  private java.math.BigDecimal tipLt;
  /**
   * 小费 比较(lte)
   */
  private java.math.BigDecimal tipLte;
  /**
   * 小费 比较(contains)
   */
  private java.math.BigDecimal tipContains;
  /**
   * 小费 比较(notcontains)
   */
  private java.math.BigDecimal tipNotcontains;
  /**
   * 小费 比较(startswith)
   */
  private java.math.BigDecimal tipStartswith;
  /**
   * 小费 比较(endswith)
   */
  private java.math.BigDecimal tipEndswith;
  /**
   * 小费 比较(isnull)
   */
  private Boolean tipIsnull;
  /**
   * 小费 比较(isnotnull)
   */
  private Boolean tipIsnotnull;

  /**
   * 折扣
   */
  private java.math.BigDecimal discount;

  /**
   * 最小折扣
   */
  private java.math.BigDecimal discountMin;

  /**
   * 最大折扣
   */
  private java.math.BigDecimal discountMax;

  /**
   * 折扣 比较(eq)
   */
  private java.math.BigDecimal discountEq;
  /**
   * 折扣 比较(neq)
   */
  private java.math.BigDecimal discountNeq;
  /**
   * 折扣 比较(gt)
   */
  private java.math.BigDecimal discountGt;
  /**
   * 折扣 比较(gte)
   */
  private java.math.BigDecimal discountGte;
  /**
   * 折扣 比较(lt)
   */
  private java.math.BigDecimal discountLt;
  /**
   * 折扣 比较(lte)
   */
  private java.math.BigDecimal discountLte;
  /**
   * 折扣 比较(contains)
   */
  private java.math.BigDecimal discountContains;
  /**
   * 折扣 比较(notcontains)
   */
  private java.math.BigDecimal discountNotcontains;
  /**
   * 折扣 比较(startswith)
   */
  private java.math.BigDecimal discountStartswith;
  /**
   * 折扣 比较(endswith)
   */
  private java.math.BigDecimal discountEndswith;
  /**
   * 折扣 比较(isnull)
   */
  private Boolean discountIsnull;
  /**
   * 折扣 比较(isnotnull)
   */
  private Boolean discountIsnotnull;

  /**
   * 商品金额
   */
  private java.math.BigDecimal amount;

  /**
   * 最小商品金额
   */
  private java.math.BigDecimal amountMin;

  /**
   * 最大商品金额
   */
  private java.math.BigDecimal amountMax;

  /**
   * 商品金额 比较(eq)
   */
  private java.math.BigDecimal amountEq;
  /**
   * 商品金额 比较(neq)
   */
  private java.math.BigDecimal amountNeq;
  /**
   * 商品金额 比较(gt)
   */
  private java.math.BigDecimal amountGt;
  /**
   * 商品金额 比较(gte)
   */
  private java.math.BigDecimal amountGte;
  /**
   * 商品金额 比较(lt)
   */
  private java.math.BigDecimal amountLt;
  /**
   * 商品金额 比较(lte)
   */
  private java.math.BigDecimal amountLte;
  /**
   * 商品金额 比较(contains)
   */
  private java.math.BigDecimal amountContains;
  /**
   * 商品金额 比较(notcontains)
   */
  private java.math.BigDecimal amountNotcontains;
  /**
   * 商品金额 比较(startswith)
   */
  private java.math.BigDecimal amountStartswith;
  /**
   * 商品金额 比较(endswith)
   */
  private java.math.BigDecimal amountEndswith;
  /**
   * 商品金额 比较(isnull)
   */
  private Boolean amountIsnull;
  /**
   * 商品金额 比较(isnotnull)
   */
  private Boolean amountIsnotnull;

  /**
   * 订单总额
   */
  private java.math.BigDecimal totalAmount;

  /**
   * 最小订单总额
   */
  private java.math.BigDecimal totalAmountMin;

  /**
   * 最大订单总额
   */
  private java.math.BigDecimal totalAmountMax;

  /**
   * 订单总额 比较(eq)
   */
  private java.math.BigDecimal totalAmountEq;
  /**
   * 订单总额 比较(neq)
   */
  private java.math.BigDecimal totalAmountNeq;
  /**
   * 订单总额 比较(gt)
   */
  private java.math.BigDecimal totalAmountGt;
  /**
   * 订单总额 比较(gte)
   */
  private java.math.BigDecimal totalAmountGte;
  /**
   * 订单总额 比较(lt)
   */
  private java.math.BigDecimal totalAmountLt;
  /**
   * 订单总额 比较(lte)
   */
  private java.math.BigDecimal totalAmountLte;
  /**
   * 订单总额 比较(contains)
   */
  private java.math.BigDecimal totalAmountContains;
  /**
   * 订单总额 比较(notcontains)
   */
  private java.math.BigDecimal totalAmountNotcontains;
  /**
   * 订单总额 比较(startswith)
   */
  private java.math.BigDecimal totalAmountStartswith;
  /**
   * 订单总额 比较(endswith)
   */
  private java.math.BigDecimal totalAmountEndswith;
  /**
   * 订单总额 比较(isnull)
   */
  private Boolean totalAmountIsnull;
  /**
   * 订单总额 比较(isnotnull)
   */
  private Boolean totalAmountIsnotnull;

  /**
   * 预估出库成本
   */
  private java.math.BigDecimal thinkDeliveryCost;

  /**
   * 最小预估出库成本
   */
  private java.math.BigDecimal thinkDeliveryCostMin;

  /**
   * 最大预估出库成本
   */
  private java.math.BigDecimal thinkDeliveryCostMax;

  /**
   * 预估出库成本 比较(eq)
   */
  private java.math.BigDecimal thinkDeliveryCostEq;
  /**
   * 预估出库成本 比较(neq)
   */
  private java.math.BigDecimal thinkDeliveryCostNeq;
  /**
   * 预估出库成本 比较(gt)
   */
  private java.math.BigDecimal thinkDeliveryCostGt;
  /**
   * 预估出库成本 比较(gte)
   */
  private java.math.BigDecimal thinkDeliveryCostGte;
  /**
   * 预估出库成本 比较(lt)
   */
  private java.math.BigDecimal thinkDeliveryCostLt;
  /**
   * 预估出库成本 比较(lte)
   */
  private java.math.BigDecimal thinkDeliveryCostLte;
  /**
   * 预估出库成本 比较(contains)
   */
  private java.math.BigDecimal thinkDeliveryCostContains;
  /**
   * 预估出库成本 比较(notcontains)
   */
  private java.math.BigDecimal thinkDeliveryCostNotcontains;
  /**
   * 预估出库成本 比较(startswith)
   */
  private java.math.BigDecimal thinkDeliveryCostStartswith;
  /**
   * 预估出库成本 比较(endswith)
   */
  private java.math.BigDecimal thinkDeliveryCostEndswith;
  /**
   * 预估出库成本 比较(isnull)
   */
  private Boolean thinkDeliveryCostIsnull;
  /**
   * 预估出库成本 比较(isnotnull)
   */
  private Boolean thinkDeliveryCostIsnotnull;

  /**
   * 预估运费
   */
  private java.math.BigDecimal deliveryThinkFreight;

  /**
   * 最小预估运费
   */
  private java.math.BigDecimal deliveryThinkFreightMin;

  /**
   * 最大预估运费
   */
  private java.math.BigDecimal deliveryThinkFreightMax;

  /**
   * 预估运费 比较(eq)
   */
  private java.math.BigDecimal deliveryThinkFreightEq;
  /**
   * 预估运费 比较(neq)
   */
  private java.math.BigDecimal deliveryThinkFreightNeq;
  /**
   * 预估运费 比较(gt)
   */
  private java.math.BigDecimal deliveryThinkFreightGt;
  /**
   * 预估运费 比较(gte)
   */
  private java.math.BigDecimal deliveryThinkFreightGte;
  /**
   * 预估运费 比较(lt)
   */
  private java.math.BigDecimal deliveryThinkFreightLt;
  /**
   * 预估运费 比较(lte)
   */
  private java.math.BigDecimal deliveryThinkFreightLte;
  /**
   * 预估运费 比较(contains)
   */
  private java.math.BigDecimal deliveryThinkFreightContains;
  /**
   * 预估运费 比较(notcontains)
   */
  private java.math.BigDecimal deliveryThinkFreightNotcontains;
  /**
   * 预估运费 比较(startswith)
   */
  private java.math.BigDecimal deliveryThinkFreightStartswith;
  /**
   * 预估运费 比较(endswith)
   */
  private java.math.BigDecimal deliveryThinkFreightEndswith;
  /**
   * 预估运费 比较(isnull)
   */
  private Boolean deliveryThinkFreightIsnull;
  /**
   * 预估运费 比较(isnotnull)
   */
  private Boolean deliveryThinkFreightIsnotnull;

  /**
   * 客付运费
   */
  private java.math.BigDecimal deliveryRealFreight;

  /**
   * 最小客付运费
   */
  private java.math.BigDecimal deliveryRealFreightMin;

  /**
   * 最大客付运费
   */
  private java.math.BigDecimal deliveryRealFreightMax;

  /**
   * 客付运费 比较(eq)
   */
  private java.math.BigDecimal deliveryRealFreightEq;
  /**
   * 客付运费 比较(neq)
   */
  private java.math.BigDecimal deliveryRealFreightNeq;
  /**
   * 客付运费 比较(gt)
   */
  private java.math.BigDecimal deliveryRealFreightGt;
  /**
   * 客付运费 比较(gte)
   */
  private java.math.BigDecimal deliveryRealFreightGte;
  /**
   * 客付运费 比较(lt)
   */
  private java.math.BigDecimal deliveryRealFreightLt;
  /**
   * 客付运费 比较(lte)
   */
  private java.math.BigDecimal deliveryRealFreightLte;
  /**
   * 客付运费 比较(contains)
   */
  private java.math.BigDecimal deliveryRealFreightContains;
  /**
   * 客付运费 比较(notcontains)
   */
  private java.math.BigDecimal deliveryRealFreightNotcontains;
  /**
   * 客付运费 比较(startswith)
   */
  private java.math.BigDecimal deliveryRealFreightStartswith;
  /**
   * 客付运费 比较(endswith)
   */
  private java.math.BigDecimal deliveryRealFreightEndswith;
  /**
   * 客付运费 比较(isnull)
   */
  private Boolean deliveryRealFreightIsnull;
  /**
   * 客付运费 比较(isnotnull)
   */
  private Boolean deliveryRealFreightIsnotnull;

  /**
   * 交易费
   */
  private java.math.BigDecimal transactionCost;

  /**
   * 最小交易费
   */
  private java.math.BigDecimal transactionCostMin;

  /**
   * 最大交易费
   */
  private java.math.BigDecimal transactionCostMax;

  /**
   * 交易费 比较(eq)
   */
  private java.math.BigDecimal transactionCostEq;
  /**
   * 交易费 比较(neq)
   */
  private java.math.BigDecimal transactionCostNeq;
  /**
   * 交易费 比较(gt)
   */
  private java.math.BigDecimal transactionCostGt;
  /**
   * 交易费 比较(gte)
   */
  private java.math.BigDecimal transactionCostGte;
  /**
   * 交易费 比较(lt)
   */
  private java.math.BigDecimal transactionCostLt;
  /**
   * 交易费 比较(lte)
   */
  private java.math.BigDecimal transactionCostLte;
  /**
   * 交易费 比较(contains)
   */
  private java.math.BigDecimal transactionCostContains;
  /**
   * 交易费 比较(notcontains)
   */
  private java.math.BigDecimal transactionCostNotcontains;
  /**
   * 交易费 比较(startswith)
   */
  private java.math.BigDecimal transactionCostStartswith;
  /**
   * 交易费 比较(endswith)
   */
  private java.math.BigDecimal transactionCostEndswith;
  /**
   * 交易费 比较(isnull)
   */
  private Boolean transactionCostIsnull;
  /**
   * 交易费 比较(isnotnull)
   */
  private Boolean transactionCostIsnotnull;

  /**
   * 预估毛利润
   */
  private java.math.BigDecimal thinkGrossProfit;

  /**
   * 最小预估毛利润
   */
  private java.math.BigDecimal thinkGrossProfitMin;

  /**
   * 最大预估毛利润
   */
  private java.math.BigDecimal thinkGrossProfitMax;

  /**
   * 预估毛利润 比较(eq)
   */
  private java.math.BigDecimal thinkGrossProfitEq;
  /**
   * 预估毛利润 比较(neq)
   */
  private java.math.BigDecimal thinkGrossProfitNeq;
  /**
   * 预估毛利润 比较(gt)
   */
  private java.math.BigDecimal thinkGrossProfitGt;
  /**
   * 预估毛利润 比较(gte)
   */
  private java.math.BigDecimal thinkGrossProfitGte;
  /**
   * 预估毛利润 比较(lt)
   */
  private java.math.BigDecimal thinkGrossProfitLt;
  /**
   * 预估毛利润 比较(lte)
   */
  private java.math.BigDecimal thinkGrossProfitLte;
  /**
   * 预估毛利润 比较(contains)
   */
  private java.math.BigDecimal thinkGrossProfitContains;
  /**
   * 预估毛利润 比较(notcontains)
   */
  private java.math.BigDecimal thinkGrossProfitNotcontains;
  /**
   * 预估毛利润 比较(startswith)
   */
  private java.math.BigDecimal thinkGrossProfitStartswith;
  /**
   * 预估毛利润 比较(endswith)
   */
  private java.math.BigDecimal thinkGrossProfitEndswith;
  /**
   * 预估毛利润 比较(isnull)
   */
  private Boolean thinkGrossProfitIsnull;
  /**
   * 预估毛利润 比较(isnotnull)
   */
  private Boolean thinkGrossProfitIsnotnull;

  /**
   * 预估毛利率
   */
  private java.math.BigDecimal thinkGrossMargin;

  /**
   * 最小预估毛利率
   */
  private java.math.BigDecimal thinkGrossMarginMin;

  /**
   * 最大预估毛利率
   */
  private java.math.BigDecimal thinkGrossMarginMax;

  /**
   * 预估毛利率 比较(eq)
   */
  private java.math.BigDecimal thinkGrossMarginEq;
  /**
   * 预估毛利率 比较(neq)
   */
  private java.math.BigDecimal thinkGrossMarginNeq;
  /**
   * 预估毛利率 比较(gt)
   */
  private java.math.BigDecimal thinkGrossMarginGt;
  /**
   * 预估毛利率 比较(gte)
   */
  private java.math.BigDecimal thinkGrossMarginGte;
  /**
   * 预估毛利率 比较(lt)
   */
  private java.math.BigDecimal thinkGrossMarginLt;
  /**
   * 预估毛利率 比较(lte)
   */
  private java.math.BigDecimal thinkGrossMarginLte;
  /**
   * 预估毛利率 比较(contains)
   */
  private java.math.BigDecimal thinkGrossMarginContains;
  /**
   * 预估毛利率 比较(notcontains)
   */
  private java.math.BigDecimal thinkGrossMarginNotcontains;
  /**
   * 预估毛利率 比较(startswith)
   */
  private java.math.BigDecimal thinkGrossMarginStartswith;
  /**
   * 预估毛利率 比较(endswith)
   */
  private java.math.BigDecimal thinkGrossMarginEndswith;
  /**
   * 预估毛利率 比较(isnull)
   */
  private Boolean thinkGrossMarginIsnull;
  /**
   * 预估毛利率 比较(isnotnull)
   */
  private Boolean thinkGrossMarginIsnotnull;

  /**
   * 平台其他费
   */
  private java.math.BigDecimal otherAmount;

  /**
   * 最小平台其他费
   */
  private java.math.BigDecimal otherAmountMin;

  /**
   * 最大平台其他费
   */
  private java.math.BigDecimal otherAmountMax;

  /**
   * 平台其他费 比较(eq)
   */
  private java.math.BigDecimal otherAmountEq;
  /**
   * 平台其他费 比较(neq)
   */
  private java.math.BigDecimal otherAmountNeq;
  /**
   * 平台其他费 比较(gt)
   */
  private java.math.BigDecimal otherAmountGt;
  /**
   * 平台其他费 比较(gte)
   */
  private java.math.BigDecimal otherAmountGte;
  /**
   * 平台其他费 比较(lt)
   */
  private java.math.BigDecimal otherAmountLt;
  /**
   * 平台其他费 比较(lte)
   */
  private java.math.BigDecimal otherAmountLte;
  /**
   * 平台其他费 比较(contains)
   */
  private java.math.BigDecimal otherAmountContains;
  /**
   * 平台其他费 比较(notcontains)
   */
  private java.math.BigDecimal otherAmountNotcontains;
  /**
   * 平台其他费 比较(startswith)
   */
  private java.math.BigDecimal otherAmountStartswith;
  /**
   * 平台其他费 比较(endswith)
   */
  private java.math.BigDecimal otherAmountEndswith;
  /**
   * 平台其他费 比较(isnull)
   */
  private Boolean otherAmountIsnull;
  /**
   * 平台其他费 比较(isnotnull)
   */
  private Boolean otherAmountIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 采购成本
   */
  private java.math.BigDecimal cgPriceAmount;

  /**
   * 最小采购成本
   */
  private java.math.BigDecimal cgPriceAmountMin;

  /**
   * 最大采购成本
   */
  private java.math.BigDecimal cgPriceAmountMax;

  /**
   * 采购成本 比较(eq)
   */
  private java.math.BigDecimal cgPriceAmountEq;
  /**
   * 采购成本 比较(neq)
   */
  private java.math.BigDecimal cgPriceAmountNeq;
  /**
   * 采购成本 比较(gt)
   */
  private java.math.BigDecimal cgPriceAmountGt;
  /**
   * 采购成本 比较(gte)
   */
  private java.math.BigDecimal cgPriceAmountGte;
  /**
   * 采购成本 比较(lt)
   */
  private java.math.BigDecimal cgPriceAmountLt;
  /**
   * 采购成本 比较(lte)
   */
  private java.math.BigDecimal cgPriceAmountLte;
  /**
   * 采购成本 比较(contains)
   */
  private java.math.BigDecimal cgPriceAmountContains;
  /**
   * 采购成本 比较(notcontains)
   */
  private java.math.BigDecimal cgPriceAmountNotcontains;
  /**
   * 采购成本 比较(startswith)
   */
  private java.math.BigDecimal cgPriceAmountStartswith;
  /**
   * 采购成本 比较(endswith)
   */
  private java.math.BigDecimal cgPriceAmountEndswith;
  /**
   * 采购成本 比较(isnull)
   */
  private Boolean cgPriceAmountIsnull;
  /**
   * 采购成本 比较(isnotnull)
   */
  private Boolean cgPriceAmountIsnotnull;

  /**
   * 库存明细成本
   */
  private java.math.BigDecimal stockAostAmount;

  /**
   * 最小库存明细成本
   */
  private java.math.BigDecimal stockAostAmountMin;

  /**
   * 最大库存明细成本
   */
  private java.math.BigDecimal stockAostAmountMax;

  /**
   * 库存明细成本 比较(eq)
   */
  private java.math.BigDecimal stockAostAmountEq;
  /**
   * 库存明细成本 比较(neq)
   */
  private java.math.BigDecimal stockAostAmountNeq;
  /**
   * 库存明细成本 比较(gt)
   */
  private java.math.BigDecimal stockAostAmountGt;
  /**
   * 库存明细成本 比较(gte)
   */
  private java.math.BigDecimal stockAostAmountGte;
  /**
   * 库存明细成本 比较(lt)
   */
  private java.math.BigDecimal stockAostAmountLt;
  /**
   * 库存明细成本 比较(lte)
   */
  private java.math.BigDecimal stockAostAmountLte;
  /**
   * 库存明细成本 比较(contains)
   */
  private java.math.BigDecimal stockAostAmountContains;
  /**
   * 库存明细成本 比较(notcontains)
   */
  private java.math.BigDecimal stockAostAmountNotcontains;
  /**
   * 库存明细成本 比较(startswith)
   */
  private java.math.BigDecimal stockAostAmountStartswith;
  /**
   * 库存明细成本 比较(endswith)
   */
  private java.math.BigDecimal stockAostAmountEndswith;
  /**
   * 库存明细成本 比较(isnull)
   */
  private Boolean stockAostAmountIsnull;
  /**
   * 库存明细成本 比较(isnotnull)
   */
  private Boolean stockAostAmountIsnotnull;

  /**
   * 实际出库成本
   */
  private java.math.BigDecimal wmsOutboundCostAmount;

  /**
   * 最小实际出库成本
   */
  private java.math.BigDecimal wmsOutboundCostAmountMin;

  /**
   * 最大实际出库成本
   */
  private java.math.BigDecimal wmsOutboundCostAmountMax;

  /**
   * 实际出库成本 比较(eq)
   */
  private java.math.BigDecimal wmsOutboundCostAmountEq;
  /**
   * 实际出库成本 比较(neq)
   */
  private java.math.BigDecimal wmsOutboundCostAmountNeq;
  /**
   * 实际出库成本 比较(gt)
   */
  private java.math.BigDecimal wmsOutboundCostAmountGt;
  /**
   * 实际出库成本 比较(gte)
   */
  private java.math.BigDecimal wmsOutboundCostAmountGte;
  /**
   * 实际出库成本 比较(lt)
   */
  private java.math.BigDecimal wmsOutboundCostAmountLt;
  /**
   * 实际出库成本 比较(lte)
   */
  private java.math.BigDecimal wmsOutboundCostAmountLte;
  /**
   * 实际出库成本 比较(contains)
   */
  private java.math.BigDecimal wmsOutboundCostAmountContains;
  /**
   * 实际出库成本 比较(notcontains)
   */
  private java.math.BigDecimal wmsOutboundCostAmountNotcontains;
  /**
   * 实际出库成本 比较(startswith)
   */
  private java.math.BigDecimal wmsOutboundCostAmountStartswith;
  /**
   * 实际出库成本 比较(endswith)
   */
  private java.math.BigDecimal wmsOutboundCostAmountEndswith;
  /**
   * 实际出库成本 比较(isnull)
   */
  private Boolean wmsOutboundCostAmountIsnull;
  /**
   * 实际出库成本 比较(isnotnull)
   */
  private Boolean wmsOutboundCostAmountIsnotnull;

  /**
   * COD费用
   */
  private java.math.BigDecimal codAmount;

  /**
   * 最小COD费用
   */
  private java.math.BigDecimal codAmountMin;

  /**
   * 最大COD费用
   */
  private java.math.BigDecimal codAmountMax;

  /**
   * COD费用 比较(eq)
   */
  private java.math.BigDecimal codAmountEq;
  /**
   * COD费用 比较(neq)
   */
  private java.math.BigDecimal codAmountNeq;
  /**
   * COD费用 比较(gt)
   */
  private java.math.BigDecimal codAmountGt;
  /**
   * COD费用 比较(gte)
   */
  private java.math.BigDecimal codAmountGte;
  /**
   * COD费用 比较(lt)
   */
  private java.math.BigDecimal codAmountLt;
  /**
   * COD费用 比较(lte)
   */
  private java.math.BigDecimal codAmountLte;
  /**
   * COD费用 比较(contains)
   */
  private java.math.BigDecimal codAmountContains;
  /**
   * COD费用 比较(notcontains)
   */
  private java.math.BigDecimal codAmountNotcontains;
  /**
   * COD费用 比较(startswith)
   */
  private java.math.BigDecimal codAmountStartswith;
  /**
   * COD费用 比较(endswith)
   */
  private java.math.BigDecimal codAmountEndswith;
  /**
   * COD费用 比较(isnull)
   */
  private Boolean codAmountIsnull;
  /**
   * COD费用 比较(isnotnull)
   */
  private Boolean codAmountIsnotnull;

  /**
   * 实际运费
   */
  private java.math.BigDecimal wmsShippingPriceAmount;

  /**
   * 最小实际运费
   */
  private java.math.BigDecimal wmsShippingPriceAmountMin;

  /**
   * 最大实际运费
   */
  private java.math.BigDecimal wmsShippingPriceAmountMax;

  /**
   * 实际运费 比较(eq)
   */
  private java.math.BigDecimal wmsShippingPriceAmountEq;
  /**
   * 实际运费 比较(neq)
   */
  private java.math.BigDecimal wmsShippingPriceAmountNeq;
  /**
   * 实际运费 比较(gt)
   */
  private java.math.BigDecimal wmsShippingPriceAmountGt;
  /**
   * 实际运费 比较(gte)
   */
  private java.math.BigDecimal wmsShippingPriceAmountGte;
  /**
   * 实际运费 比较(lt)
   */
  private java.math.BigDecimal wmsShippingPriceAmountLt;
  /**
   * 实际运费 比较(lte)
   */
  private java.math.BigDecimal wmsShippingPriceAmountLte;
  /**
   * 实际运费 比较(contains)
   */
  private java.math.BigDecimal wmsShippingPriceAmountContains;
  /**
   * 实际运费 比较(notcontains)
   */
  private java.math.BigDecimal wmsShippingPriceAmountNotcontains;
  /**
   * 实际运费 比较(startswith)
   */
  private java.math.BigDecimal wmsShippingPriceAmountStartswith;
  /**
   * 实际运费 比较(endswith)
   */
  private java.math.BigDecimal wmsShippingPriceAmountEndswith;
  /**
   * 实际运费 比较(isnull)
   */
  private Boolean wmsShippingPriceAmountIsnull;
  /**
   * 实际运费 比较(isnotnull)
   */
  private Boolean wmsShippingPriceAmountIsnotnull;

  /**
   * 礼品包装费
   */
  private java.math.BigDecimal giftWrapAmount;

  /**
   * 最小礼品包装费
   */
  private java.math.BigDecimal giftWrapAmountMin;

  /**
   * 最大礼品包装费
   */
  private java.math.BigDecimal giftWrapAmountMax;

  /**
   * 礼品包装费 比较(eq)
   */
  private java.math.BigDecimal giftWrapAmountEq;
  /**
   * 礼品包装费 比较(neq)
   */
  private java.math.BigDecimal giftWrapAmountNeq;
  /**
   * 礼品包装费 比较(gt)
   */
  private java.math.BigDecimal giftWrapAmountGt;
  /**
   * 礼品包装费 比较(gte)
   */
  private java.math.BigDecimal giftWrapAmountGte;
  /**
   * 礼品包装费 比较(lt)
   */
  private java.math.BigDecimal giftWrapAmountLt;
  /**
   * 礼品包装费 比较(lte)
   */
  private java.math.BigDecimal giftWrapAmountLte;
  /**
   * 礼品包装费 比较(contains)
   */
  private java.math.BigDecimal giftWrapAmountContains;
  /**
   * 礼品包装费 比较(notcontains)
   */
  private java.math.BigDecimal giftWrapAmountNotcontains;
  /**
   * 礼品包装费 比较(startswith)
   */
  private java.math.BigDecimal giftWrapAmountStartswith;
  /**
   * 礼品包装费 比较(endswith)
   */
  private java.math.BigDecimal giftWrapAmountEndswith;
  /**
   * 礼品包装费 比较(isnull)
   */
  private Boolean giftWrapAmountIsnull;
  /**
   * 礼品包装费 比较(isnotnull)
   */
  private Boolean giftWrapAmountIsnotnull;

  /**
   * 销售税
   */
  private java.math.BigDecimal saleTax;

  /**
   * 最小销售税
   */
  private java.math.BigDecimal saleTaxMin;

  /**
   * 最大销售税
   */
  private java.math.BigDecimal saleTaxMax;

  /**
   * 销售税 比较(eq)
   */
  private java.math.BigDecimal saleTaxEq;
  /**
   * 销售税 比较(neq)
   */
  private java.math.BigDecimal saleTaxNeq;
  /**
   * 销售税 比较(gt)
   */
  private java.math.BigDecimal saleTaxGt;
  /**
   * 销售税 比较(gte)
   */
  private java.math.BigDecimal saleTaxGte;
  /**
   * 销售税 比较(lt)
   */
  private java.math.BigDecimal saleTaxLt;
  /**
   * 销售税 比较(lte)
   */
  private java.math.BigDecimal saleTaxLte;
  /**
   * 销售税 比较(contains)
   */
  private java.math.BigDecimal saleTaxContains;
  /**
   * 销售税 比较(notcontains)
   */
  private java.math.BigDecimal saleTaxNotcontains;
  /**
   * 销售税 比较(startswith)
   */
  private java.math.BigDecimal saleTaxStartswith;
  /**
   * 销售税 比较(endswith)
   */
  private java.math.BigDecimal saleTaxEndswith;
  /**
   * 销售税 比较(isnull)
   */
  private Boolean saleTaxIsnull;
  /**
   * 销售税 比较(isnotnull)
   */
  private Boolean saleTaxIsnotnull;

  /**
   * 积分成本
   */
  private java.math.BigDecimal pointsGrantedAmount;

  /**
   * 最小积分成本
   */
  private java.math.BigDecimal pointsGrantedAmountMin;

  /**
   * 最大积分成本
   */
  private java.math.BigDecimal pointsGrantedAmountMax;

  /**
   * 积分成本 比较(eq)
   */
  private java.math.BigDecimal pointsGrantedAmountEq;
  /**
   * 积分成本 比较(neq)
   */
  private java.math.BigDecimal pointsGrantedAmountNeq;
  /**
   * 积分成本 比较(gt)
   */
  private java.math.BigDecimal pointsGrantedAmountGt;
  /**
   * 积分成本 比较(gte)
   */
  private java.math.BigDecimal pointsGrantedAmountGte;
  /**
   * 积分成本 比较(lt)
   */
  private java.math.BigDecimal pointsGrantedAmountLt;
  /**
   * 积分成本 比较(lte)
   */
  private java.math.BigDecimal pointsGrantedAmountLte;
  /**
   * 积分成本 比较(contains)
   */
  private java.math.BigDecimal pointsGrantedAmountContains;
  /**
   * 积分成本 比较(notcontains)
   */
  private java.math.BigDecimal pointsGrantedAmountNotcontains;
  /**
   * 积分成本 比较(startswith)
   */
  private java.math.BigDecimal pointsGrantedAmountStartswith;
  /**
   * 积分成本 比较(endswith)
   */
  private java.math.BigDecimal pointsGrantedAmountEndswith;
  /**
   * 积分成本 比较(isnull)
   */
  private Boolean pointsGrantedAmountIsnull;
  /**
   * 积分成本 比较(isnotnull)
   */
  private Boolean pointsGrantedAmountIsnotnull;

  /**
   * 其他费用
   */
  private java.math.BigDecimal otherFee;

  /**
   * 最小其他费用
   */
  private java.math.BigDecimal otherFeeMin;

  /**
   * 最大其他费用
   */
  private java.math.BigDecimal otherFeeMax;

  /**
   * 其他费用 比较(eq)
   */
  private java.math.BigDecimal otherFeeEq;
  /**
   * 其他费用 比较(neq)
   */
  private java.math.BigDecimal otherFeeNeq;
  /**
   * 其他费用 比较(gt)
   */
  private java.math.BigDecimal otherFeeGt;
  /**
   * 其他费用 比较(gte)
   */
  private java.math.BigDecimal otherFeeGte;
  /**
   * 其他费用 比较(lt)
   */
  private java.math.BigDecimal otherFeeLt;
  /**
   * 其他费用 比较(lte)
   */
  private java.math.BigDecimal otherFeeLte;
  /**
   * 其他费用 比较(contains)
   */
  private java.math.BigDecimal otherFeeContains;
  /**
   * 其他费用 比较(notcontains)
   */
  private java.math.BigDecimal otherFeeNotcontains;
  /**
   * 其他费用 比较(startswith)
   */
  private java.math.BigDecimal otherFeeStartswith;
  /**
   * 其他费用 比较(endswith)
   */
  private java.math.BigDecimal otherFeeEndswith;
  /**
   * 其他费用 比较(isnull)
   */
  private Boolean otherFeeIsnull;
  /**
   * 其他费用 比较(isnotnull)
   */
  private Boolean otherFeeIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
